refs: RUM-16880

This PR addresses a few gaps in storage-thread functionality that could
lead to runaway disk usage in certain situations, such as when a the
tracking consent value never changes from `pending`.

 ### Problems

Compared to the mobile SDKs, the C++ SDK has the following limitations:

1. Age-based file eviction (for files older than 18h) only runs on the
   granted-consent directory; there's no such mechanism bounding the
   growth of the pending-consent directory.

2. The C++ SDK imposes no whole-directory disk usage limitation- on
   mobile platforms, no single feature's event storage directory is
   allowed to exceed 512 MB.

3. Less critically: whereas the mobile SDKs impose a limit on the
   maximum size of a single event (no event can exceed 512 kB on
   Android; 1MB on iOS), the C++ SDK only applies a 4MB limit to the
   entire batch

The combination of issues 1 and 2 means that current versions of the C++
SDK will allow batches of event data stored in the pending-consent
directory to remain on disk, causing overall disk usage to grow
unbounded.

 ### Fixes

This PR addresses all three of these problems. Key code changes:

- `IFilesystem` now supports `GetFileSize()`, implemented via `stat()`
  or `GetFileAttributesExW()`

- In the upload thread, when actually processing batch files for upload,
  we still reject (and delete) files older than 18h, just as we did
  before- applying the 18h limit to the consent-granted directory is a
  natural side effect of the ordinary file age check on upload.

- We now _also_ apply the 18h limit to the consent-pending directory, as
  an explicit check that's run on a per-feature basis, also in the
  upload thread, every time an upload cycle is invoked for that feature,
  regardless of whether anything was uploaded.

- In the storage thread, when we're preparing a brand new batch file for
  write, we now stat all existing batch files in the directory (ignoring
  files with non-numeric names entirely), check if they sum to greater
  than 512 MB, and iteratively delete files (oldest-first) until we're
  back under that limit.

- In the storage thread, when we write any event, we now enforce a
  maximum per-event size limit of 512 kB.

As a result, when the SDK is operated normally with the same set of
features registered, it will maintain an overall disk usage footprint no
greater than `512 MB * N`, where N is the number of features registered.

Refactoring changes:

- In `upload_thread.cpp`, we now check file age in two separate code
  paths (normal upload and explicit pending-dir eviction check), so we
  use a new `batch_file_age()` helper to compute the age of a file given
  its filename and the current time

- In `storage_write.cpp`, when we need to cut a new batch file, we
  preemptively list the names of all files in the directory we're about
  to write to. Previously, this list of filenames was just used to
  prevent conflicts when naming the new file. As of this PR, we _also_
  need to use this list of filenames when performing the size-based
  eviction check. As a result, our directory listing (via
  `CacheKnownFilenames()`) has been pulled up to a higher scope, and we
  rely on the fact that `_last_known_filenames` is pre-populated in both
  of those lower-level routines:
    - `CacheKnownFilenames()` runs first, populating the set of
      filenames, filtering it to only numerically-named files, and
      sorting it
    - `PurgeDirectoryIfNeeded()` runs next, stat'ing all files in that
      list; if it deletes old files; it removes them from the front of
      the list, mutating `_last_known_filenames`
    - `GetFilenameForNextWrite()` runs next, using
      `_last_known_filenames` as-is (so we only fetch the directory
      listing once per new batch file creation)

Test changes:

- `MockFilesystem` now supports `GetFileSize()`, including targeted mock
   failures

- `storage_write_test.cpp` now validates:
    - Single event exceeding max event size is dropped
    - Single event exactly matching max event size is accepted
    - If batch dir exceeds directory size limit on write, old files are
      purged
    - If batch dir is within size limit on write, no files are purged
    - If foreign (non-SDK-written) files exist in batch dir, they are
      ignored on purge
    - Both pending and granted directories are subject to file size
      limit and will be purged the same
    - Filesystem errors in size checks are handled gracefully

- `upload_thread_test.cpp` now validates:
    - If a pending dir has files older than 18h when an upload cycle
      runs, those files are deleted
    - If all files in a pending dir are newer than 18h, the pendir dir
      is left untouched
    - Foreign files older than 18h are left alone, never deleted
    - If we fail to list files at the start of an eviction check, we
      skip the age-based eviction process entirely

This ensures that an early-out on the upload cycle due to failure to
list files in the granted directory will not prevent deletion of
outdated files in the pending directory.

We still run the pending-directory eviction check once per upload cycle;
it just runs at the start of the cycle (before upload attempts) rather
than at the end (after upload attempts).